home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / share / pyshared / xdg / Menu.py < prev    next >
Encoding:
Python Source  |  2009-10-28  |  35.5 KB  |  1,075 lines
  1. """
  2. Implementation of the XDG Menu Specification Version 1.0.draft-1
  3. http://standards.freedesktop.org/menu-spec/
  4. """
  5.  
  6. from __future__ import generators
  7. import locale, os, xml.dom.minidom
  8.  
  9. from xdg.BaseDirectory import *
  10. from xdg.DesktopEntry import *
  11. from xdg.Exceptions import *
  12.  
  13. import xdg.Locale
  14. import xdg.Config
  15.  
  16. ELEMENT_NODE = xml.dom.Node.ELEMENT_NODE
  17.  
  18. # for python <= 2.3
  19. try:
  20.     reversed = reversed
  21. except NameError:
  22.     def reversed(x):
  23.         return x[::-1]
  24.  
  25. class Menu:
  26.     def __init__(self):
  27.         # Public stuff
  28.         self.Name = ""
  29.         self.Directory = None
  30.         self.Entries = []
  31.         self.Doc = ""
  32.         self.Filename = ""
  33.         self.Depth = 0
  34.         self.Parent = None
  35.         self.NotInXml = False
  36.  
  37.         # Can be one of Deleted/NoDisplay/Hidden/Empty/NotShowIn or True
  38.         self.Show = True
  39.         self.Visible = 0
  40.  
  41.         # Private stuff, only needed for parsing
  42.         self.AppDirs = []
  43.         self.DefaultLayout = None
  44.         self.Deleted = "notset"
  45.         self.Directories = []
  46.         self.DirectoryDirs = []
  47.         self.Layout = None
  48.         self.MenuEntries = []
  49.         self.Moves = []
  50.         self.OnlyUnallocated = "notset"
  51.         self.Rules = []
  52.         self.Submenus = []
  53.  
  54.     def __str__(self):
  55.         return self.Name
  56.  
  57.     def __add__(self, other):
  58.         for dir in other.AppDirs:
  59.             self.AppDirs.append(dir)
  60.  
  61.         for dir in other.DirectoryDirs:
  62.             self.DirectoryDirs.append(dir)
  63.  
  64.         for directory in other.Directories:
  65.             self.Directories.append(directory)
  66.  
  67.         if other.Deleted != "notset":
  68.             self.Deleted = other.Deleted
  69.  
  70.         if other.OnlyUnallocated != "notset":
  71.             self.OnlyUnallocated = other.OnlyUnallocated
  72.  
  73.         if other.Layout:
  74.             self.Layout = other.Layout
  75.  
  76.         if other.DefaultLayout:
  77.             self.DefaultLayout = other.DefaultLayout
  78.  
  79.         for rule in other.Rules:
  80.             self.Rules.append(rule)
  81.  
  82.         for move in other.Moves:
  83.             self.Moves.append(move)
  84.  
  85.         for submenu in other.Submenus:
  86.             self.addSubmenu(submenu)
  87.  
  88.         return self
  89.  
  90.     # FIXME: Performance: cache getName()
  91.     def __cmp__(self, other):
  92.         return locale.strcoll(self.getName(), other.getName())
  93.  
  94.     def __eq__(self, other):
  95.         if self.Name == str(other):
  96.             return True
  97.         else:
  98.             return False
  99.  
  100.     """ PUBLIC STUFF """
  101.     def getEntries(self, hidden=False):
  102.         for entry in self.Entries:
  103.             if hidden == True:
  104.                 yield entry
  105.             elif entry.Show == True:
  106.                 yield entry
  107.  
  108.     # FIXME: Add searchEntry/seaqrchMenu function
  109.     # search for name/comment/genericname/desktopfileide
  110.     # return multiple items
  111.  
  112.     def getMenuEntry(self, desktopfileid, deep = False):
  113.         for menuentry in self.MenuEntries:
  114.             if menuentry.DesktopFileID == desktopfileid:
  115.                 return menuentry
  116.         if deep == True:
  117.             for submenu in self.Submenus:
  118.                 submenu.getMenuEntry(desktopfileid, deep)
  119.  
  120.     def getMenu(self, path):
  121.         array = path.split("/", 1)
  122.         for submenu in self.Submenus:
  123.             if submenu.Name == array[0]:
  124.                 if len(array) > 1:
  125.                     return submenu.getMenu(array[1])
  126.                 else:
  127.                     return submenu
  128.  
  129.     def getPath(self, org=False, toplevel=False):
  130.         parent = self
  131.         names=[]
  132.         while 1:
  133.             if org:
  134.                 names.append(parent.Name)
  135.             else:
  136.                 names.append(parent.getName())
  137.             if parent.Depth > 0:
  138.                 parent = parent.Parent
  139.             else:
  140.                 break
  141.         names.reverse()
  142.         path = ""
  143.         if toplevel == False:
  144.             names.pop(0)
  145.         for name in names:
  146.             path = os.path.join(path, name)
  147.         return path
  148.  
  149.     def getName(self):
  150.         try:
  151.             return self.Directory.DesktopEntry.getName()
  152.         except AttributeError:
  153.             return self.Name
  154.  
  155.     def getGenericName(self):
  156.         try:
  157.             return self.Directory.DesktopEntry.getGenericName()
  158.         except AttributeError:
  159.             return ""
  160.  
  161.     def getComment(self):
  162.         try:
  163.             return self.Directory.DesktopEntry.getComment()
  164.         except AttributeError:
  165.             return ""
  166.  
  167.     def getIcon(self):
  168.         try:
  169.             return self.Directory.DesktopEntry.getIcon()
  170.         except AttributeError:
  171.             return ""
  172.  
  173.     """ PRIVATE STUFF """
  174.     def addSubmenu(self, newmenu):
  175.         for submenu in self.Submenus:
  176.             if submenu == newmenu:
  177.                 submenu += newmenu
  178.                 break
  179.         else:
  180.             self.Submenus.append(newmenu)
  181.             newmenu.Parent = self
  182.             newmenu.Depth = self.Depth + 1
  183.  
  184. class Move:
  185.     "A move operation"
  186.     def __init__(self, node=None):
  187.         if node:
  188.             self.parseNode(node)
  189.         else:
  190.             self.Old = ""
  191.             self.New = ""
  192.  
  193.     def __cmp__(self, other):
  194.         return cmp(self.Old, other.Old)
  195.  
  196.     def parseNode(self, node):
  197.         for child in node.childNodes:
  198.             if child.nodeType == ELEMENT_NODE:
  199.                 if child.tagName == "Old":
  200.                     try:
  201.                         self.parseOld(child.childNodes[0].nodeValue)
  202.                     except IndexError:
  203.                         raise ValidationError('Old cannot be empty', '??')                                            
  204.                 elif child.tagName == "New":
  205.                     try:
  206.                         self.parseNew(child.childNodes[0].nodeValue)
  207.                     except IndexError:
  208.                         raise ValidationError('New cannot be empty', '??')                                            
  209.  
  210.     def parseOld(self, value):
  211.         self.Old = value
  212.     def parseNew(self, value):
  213.         self.New = value
  214.  
  215.  
  216. class Layout:
  217.     "Menu Layout class"
  218.     def __init__(self, node=None):
  219.         self.order = []
  220.         if node:
  221.             self.show_empty = node.getAttribute("show_empty") or "false"
  222.             self.inline = node.getAttribute("inline") or "false"
  223.             self.inline_limit = node.getAttribute("inline_limit") or 4
  224.             self.inline_header = node.getAttribute("inline_header") or "true"
  225.             self.inline_alias = node.getAttribute("inline_alias") or "false"
  226.             self.inline_limit = int(self.inline_limit)
  227.             self.parseNode(node)
  228.         else:
  229.             self.show_empty = "false"
  230.             self.inline = "false"
  231.             self.inline_limit = 4
  232.             self.inline_header = "true"
  233.             self.inline_alias = "false"
  234.             self.order.append(["Merge", "menus"])
  235.             self.order.append(["Merge", "files"])
  236.  
  237.     def parseNode(self, node):
  238.         for child in node.childNodes:
  239.             if child.nodeType == ELEMENT_NODE:
  240.                 if child.tagName == "Menuname":
  241.                     try:
  242.                         self.parseMenuname(
  243.                             child.childNodes[0].nodeValue,
  244.                             child.getAttribute("show_empty") or "false",
  245.                             child.getAttribute("inline") or "false",
  246.                             child.getAttribute("inline_limit") or 4,
  247.                             child.getAttribute("inline_header") or "true",
  248.                             child.getAttribute("inline_alias") or "false" )
  249.                     except IndexError:
  250.                         raise ValidationError('Menuname cannot be empty', "")
  251.                 elif child.tagName == "Separator":
  252.                     self.parseSeparator()
  253.                 elif child.tagName == "Filename":
  254.                     try:
  255.                         self.parseFilename(child.childNodes[0].nodeValue)
  256.                     except IndexError:
  257.                         raise ValidationError('Filename cannot be empty', "")
  258.                 elif child.tagName == "Merge":
  259.                     self.parseMerge(child.getAttribute("type") or "all")
  260.  
  261.     def parseMenuname(self, value, empty="false", inline="false", inline_limit=4, inline_header="true", inline_alias="false"):
  262.         self.order.append(["Menuname", value, empty, inline, inline_limit, inline_header, inline_alias])
  263.         self.order[-1][4] = int(self.order[-1][4])
  264.  
  265.     def parseSeparator(self):
  266.         self.order.append(["Separator"])
  267.  
  268.     def parseFilename(self, value):
  269.         self.order.append(["Filename", value])
  270.  
  271.     def parseMerge(self, type="all"):
  272.         self.order.append(["Merge", type])
  273.  
  274.  
  275. class Rule:
  276.     "Inlcude / Exclude Rules Class"
  277.     def __init__(self, type, node=None):
  278.         # Type is Include or Exclude
  279.         self.Type = type
  280.         # Rule is a python expression
  281.         self.Rule = ""
  282.  
  283.         # Private attributes, only needed for parsing
  284.         self.Depth = 0
  285.         self.Expr = [ "or" ]
  286.         self.New = True
  287.  
  288.         # Begin parsing
  289.         if node:
  290.             self.parseNode(node)
  291.             self.compile()
  292.  
  293.     def __str__(self):
  294.         return self.Rule
  295.  
  296.     def compile(self):
  297.         exec("""
  298. def do(menuentries, type, run):
  299.     for menuentry in menuentries:
  300.         if run == 2 and ( menuentry.MatchedInclude == True \
  301.         or menuentry.Allocated == True ):
  302.             continue
  303.         elif %s:
  304.             if type == "Include":
  305.                 menuentry.Add = True
  306.                 menuentry.MatchedInclude = True
  307.             else:
  308.                 menuentry.Add = False
  309.     return menuentries
  310. """ % self.Rule) in self.__dict__
  311.  
  312.     def parseNode(self, node):
  313.         for child in node.childNodes:
  314.             if child.nodeType == ELEMENT_NODE:
  315.                 if child.tagName == 'Filename':
  316.                     try:
  317.                         self.parseFilename(child.childNodes[0].nodeValue)
  318.                     except IndexError:
  319.                         raise ValidationError('Filename cannot be empty', "???")
  320.                 elif child.tagName == 'Category':
  321.                     try:
  322.                         self.parseCategory(child.childNodes[0].nodeValue)
  323.                     except IndexError:
  324.                         raise ValidationError('Category cannot be empty', "???")
  325.                 elif child.tagName == 'All':
  326.                     self.parseAll()
  327.                 elif child.tagName == 'And':
  328.                     self.parseAnd(child)
  329.                 elif child.tagName == 'Or':
  330.                     self.parseOr(child)
  331.                 elif child.tagName == 'Not':
  332.                     self.parseNot(child)
  333.  
  334.     def parseNew(self, set=True):
  335.         if not self.New:
  336.             self.Rule += " " + self.Expr[self.Depth] + " "
  337.         if not set:
  338.             self.New = True
  339.         elif set:
  340.             self.New = False
  341.  
  342.     def parseFilename(self, value):
  343.         self.parseNew()
  344.         self.Rule += "menuentry.DesktopFileID == '%s'" % value.strip().replace("\\", r"\\").replace("'", r"\'")
  345.  
  346.     def parseCategory(self, value):
  347.         self.parseNew()
  348.         self.Rule += "'%s' in menuentry.Categories" % value.strip()
  349.  
  350.     def parseAll(self):
  351.         self.parseNew()
  352.         self.Rule += "True"
  353.  
  354.     def parseAnd(self, node):
  355.         self.parseNew(False)
  356.         self.Rule += "("
  357.         self.Depth += 1
  358.         self.Expr.append("and")
  359.         self.parseNode(node)
  360.         self.Depth -= 1
  361.         self.Expr.pop()
  362.         self.Rule += ")"
  363.  
  364.     def parseOr(self, node):
  365.         self.parseNew(False)
  366.         self.Rule += "("
  367.         self.Depth += 1
  368.         self.Expr.append("or")
  369.         self.parseNode(node)
  370.         self.Depth -= 1
  371.         self.Expr.pop()
  372.         self.Rule += ")"
  373.  
  374.     def parseNot(self, node):
  375.         self.parseNew(False)
  376.         self.Rule += "not ("
  377.         self.Depth += 1
  378.         self.Expr.append("or")
  379.         self.parseNode(node)
  380.         self.Depth -= 1
  381.         self.Expr.pop()
  382.         self.Rule += ")"
  383.  
  384.  
  385. class MenuEntry:
  386.     "Wrapper for 'Menu Style' Desktop Entries"
  387.     def __init__(self, filename, dir="", prefix=""):
  388.         # Create entry
  389.         self.DesktopEntry = DesktopEntry(os.path.join(dir,filename))
  390.         self.setAttributes(filename, dir, prefix)
  391.  
  392.         # Can be one of Deleted/Hidden/Empty/NotShowIn/NoExec or True
  393.         self.Show = True
  394.  
  395.         # Semi-Private
  396.         self.Original = None
  397.         self.Parents = []
  398.  
  399.         # Private Stuff
  400.         self.Allocated = False
  401.         self.Add = False
  402.         self.MatchedInclude = False
  403.  
  404.         # Caching
  405.         self.Categories = self.DesktopEntry.getCategories()
  406.  
  407.     def save(self):
  408.         if self.DesktopEntry.tainted == True:
  409.             self.DesktopEntry.write()
  410.  
  411.     def getDir(self):
  412.         return self.DesktopEntry.filename.replace(self.Filename, '')
  413.  
  414.     def getType(self):
  415.         # Can be one of System/User/Both
  416.         if xdg.Config.root_mode == False:
  417.             if self.Original:
  418.                 return "Both"
  419.             elif xdg_data_dirs[0] in self.DesktopEntry.filename:
  420.                 return "User"
  421.             else:
  422.                 return "System"
  423.         else:
  424.             return "User"
  425.  
  426.     def setAttributes(self, filename, dir="", prefix=""):
  427.         self.Filename = filename
  428.         self.Prefix = prefix
  429.         self.DesktopFileID = os.path.join(prefix,filename).replace("/", "-")
  430.  
  431.         if not os.path.isabs(self.DesktopEntry.filename):
  432.             self.__setFilename()
  433.  
  434.     def updateAttributes(self):
  435.         if self.getType() == "System":
  436.             self.Original = MenuEntry(self.Filename, self.getDir(), self.Prefix)
  437.             self.__setFilename()
  438.  
  439.     def __setFilename(self):
  440.         if xdg.Config.root_mode == False:
  441.             path = xdg_data_dirs[0]
  442.         else:
  443.             path= xdg_data_dirs[1]
  444.  
  445.         if self.DesktopEntry.getType() == "Application":
  446.             dir = os.path.join(path, "applications")
  447.         else:
  448.             dir = os.path.join(path, "desktop-directories")
  449.  
  450.         self.DesktopEntry.filename = os.path.join(dir, self.Filename)
  451.  
  452.     def __cmp__(self, other):
  453.         return locale.strcoll(self.DesktopEntry.getName(), other.DesktopEntry.getName())
  454.  
  455.     def __eq__(self, other):
  456.         if self.DesktopFileID == str(other):
  457.             return True
  458.         else:
  459.             return False
  460.  
  461.     def __repr__(self):
  462.         return self.DesktopFileID
  463.  
  464.  
  465. class Separator:
  466.     "Just a dummy class for Separators"
  467.     def __init__(self, parent):
  468.         self.Parent = parent
  469.         self.Show = True
  470.  
  471.  
  472. class Header:
  473.     "Class for Inline Headers"
  474.     def __init__(self, name, generic_name, comment):
  475.         self.Name = name
  476.         self.GenericName = generic_name
  477.         self.Comment = comment
  478.  
  479.     def __str__(self):
  480.         return self.Name
  481.  
  482.  
  483. tmp = {}
  484.  
  485. def __getFileName(filename):
  486.     dirs = xdg_config_dirs[:]
  487.     if xdg.Config.root_mode == True:
  488.         dirs.pop(0)
  489.  
  490.     for dir in dirs:
  491.         menuname = os.path.join (dir, "menus" , filename)
  492.         if os.path.isdir(dir) and os.path.isfile(menuname):
  493.             return menuname
  494.  
  495. def parse(filename=None):
  496.     # conver to absolute path
  497.     if filename and not os.path.isabs(filename):
  498.         filename = __getFileName(filename)
  499.  
  500.     # use default if no filename given
  501.     if not filename: 
  502.         candidate = os.environ.get('XDG_MENU_PREFIX', '') + "applications.menu"
  503.         filename = __getFileName(candidate)
  504.         
  505.     if not filename:
  506.         raise ParsingError('File not found', "/etc/xdg/menus/%s" % candidate)
  507.  
  508.     # check if it is a .menu file
  509.     if not os.path.splitext(filename)[1] == ".menu":
  510.         raise ParsingError('Not a .menu file', filename)
  511.  
  512.     # create xml parser
  513.     try:
  514.         doc = xml.dom.minidom.parse(filename)
  515.     except xml.parsers.expat.ExpatError:
  516.         raise ParsingError('Not a valid .menu file', filename)
  517.  
  518.     # parse menufile
  519.     tmp["Root"] = ""
  520.     tmp["mergeFiles"] = []
  521.     tmp["DirectoryDirs"] = []
  522.     tmp["cache"] = MenuEntryCache()
  523.  
  524.     __parse(doc, filename, tmp["Root"])
  525.     __parsemove(tmp["Root"])
  526.     __postparse(tmp["Root"])
  527.  
  528.     tmp["Root"].Doc = doc
  529.     tmp["Root"].Filename = filename
  530.  
  531.     # generate the menu
  532.     __genmenuNotOnlyAllocated(tmp["Root"])
  533.     __genmenuOnlyAllocated(tmp["Root"])
  534.  
  535.     # and finally sort
  536.     sort(tmp["Root"])
  537.  
  538.     return tmp["Root"]
  539.  
  540.  
  541. def __parse(node, filename, parent=None):
  542.     for child in node.childNodes:
  543.         if child.nodeType == ELEMENT_NODE:
  544.             if child.tagName == 'Menu':
  545.                 __parseMenu(child, filename, parent)
  546.             elif child.tagName == 'AppDir':
  547.                 try:
  548.                     __parseAppDir(child.childNodes[0].nodeValue, filename, parent)
  549.                 except IndexError:
  550.                     raise ValidationError('AppDir cannot be empty', filename)
  551.             elif child.tagName == 'DefaultAppDirs':
  552.                 __parseDefaultAppDir(filename, parent)
  553.             elif child.tagName == 'DirectoryDir':
  554.                 try:
  555.                     __parseDirectoryDir(child.childNodes[0].nodeValue, filename, parent)
  556.                 except IndexError:
  557.                     raise ValidationError('DirectoryDir cannot be empty', filename)
  558.             elif child.tagName == 'DefaultDirectoryDirs':
  559.                 __parseDefaultDirectoryDir(filename, parent)
  560.             elif child.tagName == 'Name' :
  561.                 try:
  562.                     parent.Name = child.childNodes[0].nodeValue
  563.                 except IndexError:
  564.                     raise ValidationError('Name cannot be empty', filename)
  565.             elif child.tagName == 'Directory' :
  566.                 try:
  567.                     parent.Directories.append(child.childNodes[0].nodeValue)
  568.                 except IndexError:
  569.                     raise ValidationError('Directory cannot be empty', filename)
  570.             elif child.tagName == 'OnlyUnallocated':
  571.                 parent.OnlyUnallocated = True
  572.             elif child.tagName == 'NotOnlyUnallocated':
  573.                 parent.OnlyUnallocated = False
  574.             elif child.tagName == 'Deleted':
  575.                 parent.Deleted = True
  576.             elif child.tagName == 'NotDeleted':
  577.                 parent.Deleted = False
  578.             elif child.tagName == 'Include' or child.tagName == 'Exclude':
  579.                 parent.Rules.append(Rule(child.tagName, child))
  580.             elif child.tagName == 'MergeFile':
  581.                 try:
  582.                     if child.getAttribute("type") == "parent":
  583.                         __parseMergeFile("applications.menu", child, filename, parent)
  584.                     else:
  585.                         __parseMergeFile(child.childNodes[0].nodeValue, child, filename, parent)
  586.                 except IndexError:
  587.                     raise ValidationError('MergeFile cannot be empty', filename)
  588.             elif child.tagName == 'MergeDir':
  589.                 try:
  590.                     __parseMergeDir(child.childNodes[0].nodeValue, child, filename, parent)
  591.                 except IndexError:
  592.                     raise ValidationError('MergeDir cannot be empty', filename)
  593.             elif child.tagName == 'DefaultMergeDirs':
  594.                 __parseDefaultMergeDirs(child, filename, parent)
  595.             elif child.tagName == 'Move':
  596.                 parent.Moves.append(Move(child))
  597.             elif child.tagName == 'Layout':
  598.                 if len(child.childNodes) > 1:
  599.                     parent.Layout = Layout(child)
  600.             elif child.tagName == 'DefaultLayout':
  601.                 if len(child.childNodes) > 1:
  602.                     parent.DefaultLayout = Layout(child)
  603.             elif child.tagName == 'LegacyDir':
  604.                 try:
  605.                     __parseLegacyDir(child.childNodes[0].nodeValue, child.getAttribute("prefix"), filename, parent)
  606.                 except IndexError:
  607.                     raise ValidationError('LegacyDir cannot be empty', filename)
  608.             elif child.tagName == 'KDELegacyDirs':
  609.                 __parseKDELegacyDirs(filename, parent)
  610.  
  611. def __parsemove(menu):
  612.     for submenu in menu.Submenus:
  613.         __parsemove(submenu)
  614.  
  615.     # parse move operations
  616.     for move in menu.Moves:
  617.         move_from_menu = menu.getMenu(move.Old)
  618.         if move_from_menu:
  619.             move_to_menu = menu.getMenu(move.New)
  620.  
  621.             menus = move.New.split("/")
  622.             oldparent = None
  623.             while len(menus) > 0:
  624.                 if not oldparent:
  625.                     oldparent = menu
  626.                 newmenu = oldparent.getMenu(menus[0])
  627.                 if not newmenu:
  628.                     newmenu = Menu()
  629.                     newmenu.Name = menus[0]
  630.                     if len(menus) > 1:
  631.                         newmenu.NotInXml = True
  632.                     oldparent.addSubmenu(newmenu)
  633.                 oldparent = newmenu
  634.                 menus.pop(0)
  635.  
  636.             newmenu += move_from_menu
  637.             move_from_menu.Parent.Submenus.remove(move_from_menu)
  638.  
  639. def __postparse(menu):
  640.     # unallocated / deleted
  641.     if menu.Deleted == "notset":
  642.         menu.Deleted = False
  643.     if menu.OnlyUnallocated == "notset":
  644.         menu.OnlyUnallocated = False
  645.  
  646.     # Layout Tags
  647.     if not menu.Layout or not menu.DefaultLayout:
  648.         if menu.DefaultLayout:
  649.             menu.Layout = menu.DefaultLayout
  650.         elif menu.Layout:
  651.             if menu.Depth > 0:
  652.                 menu.DefaultLayout = menu.Parent.DefaultLayout
  653.             else:
  654.                 menu.DefaultLayout = Layout()
  655.         else:
  656.             if menu.Depth > 0:
  657.                 menu.Layout = menu.Parent.DefaultLayout
  658.                 menu.DefaultLayout = menu.Parent.DefaultLayout
  659.             else:
  660.                 menu.Layout = Layout()
  661.                 menu.DefaultLayout = Layout()
  662.  
  663.     # add parent's app/directory dirs
  664.     if menu.Depth > 0:
  665.         menu.AppDirs = menu.Parent.AppDirs + menu.AppDirs
  666.         menu.DirectoryDirs = menu.Parent.DirectoryDirs + menu.DirectoryDirs
  667.  
  668.     # remove duplicates
  669.     menu.Directories = __removeDuplicates(menu.Directories)
  670.     menu.DirectoryDirs = __removeDuplicates(menu.DirectoryDirs)
  671.     menu.AppDirs = __removeDuplicates(menu.AppDirs)
  672.  
  673.     # go recursive through all menus
  674.     for submenu in menu.Submenus:
  675.         __postparse(submenu)
  676.  
  677.     # reverse so handling is easier
  678.     menu.Directories.reverse()
  679.     menu.DirectoryDirs.reverse()
  680.     menu.AppDirs.reverse()
  681.  
  682.     # get the valid .directory file out of the list
  683.     for directory in menu.Directories:
  684.         for dir in menu.DirectoryDirs:
  685.             if os.path.isfile(os.path.join(dir, directory)):
  686.                 menuentry = MenuEntry(directory, dir)
  687.                 if not menu.Directory:
  688.                     menu.Directory = menuentry
  689.                 elif menuentry.getType() == "System":
  690.                     if menu.Directory.getType() == "User":
  691.                         menu.Directory.Original = menuentry
  692.         if menu.Directory:
  693.             break
  694.  
  695.  
  696. # Menu parsing stuff
  697. def __parseMenu(child, filename, parent):
  698.     m = Menu()
  699.     __parse(child, filename, m)
  700.     if parent:
  701.         parent.addSubmenu(m)
  702.     else:
  703.         tmp["Root"] = m
  704.  
  705. # helper function
  706. def __check(value, filename, type):
  707.     path = os.path.dirname(filename)
  708.  
  709.     if not os.path.isabs(value):
  710.         value = os.path.join(path, value)
  711.  
  712.     value = os.path.abspath(value)
  713.  
  714.     if type == "dir" and os.path.exists(value) and os.path.isdir(value):
  715.         return value
  716.     elif type == "file" and os.path.exists(value) and os.path.isfile(value):
  717.         return value
  718.     else:
  719.         return False
  720.  
  721. # App/Directory Dir Stuff
  722. def __parseAppDir(value, filename, parent):
  723.     value = __check(value, filename, "dir")
  724.     if value:
  725.         parent.AppDirs.append(value)
  726.  
  727. def __parseDefaultAppDir(filename, parent):
  728.     for dir in reversed(xdg_data_dirs):
  729.         __parseAppDir(os.path.join(dir, "applications"), filename, parent)
  730.  
  731. def __parseDirectoryDir(value, filename, parent):
  732.     value = __check(value, filename, "dir")
  733.     if value:
  734.         parent.DirectoryDirs.append(value)
  735.  
  736. def __parseDefaultDirectoryDir(filename, parent):
  737.     for dir in reversed(xdg_data_dirs):
  738.         __parseDirectoryDir(os.path.join(dir, "desktop-directories"), filename, parent)
  739.  
  740. # Merge Stuff
  741. def __parseMergeFile(value, child, filename, parent):
  742.     if child.getAttribute("type") == "parent":
  743.         for dir in xdg_config_dirs:
  744.             rel_file = filename.replace(dir, "").strip("/")
  745.             if rel_file != filename:
  746.                 for p in xdg_config_dirs:
  747.                     if dir == p:
  748.                         continue
  749.                     if os.path.isfile(os.path.join(p,rel_file)):
  750.                         __mergeFile(os.path.join(p,rel_file),child,parent)
  751.                         break
  752.     else:
  753.         value = __check(value, filename, "file")
  754.         if value:
  755.             __mergeFile(value, child, parent)
  756.  
  757. def __parseMergeDir(value, child, filename, parent):
  758.     value = __check(value, filename, "dir")
  759.     if value:
  760.         for item in os.listdir(value):
  761.             try:
  762.                 if os.path.splitext(item)[1] == ".menu":
  763.                     __mergeFile(os.path.join(value, item), child, parent)
  764.             except UnicodeDecodeError:
  765.                 continue
  766.  
  767. def __parseDefaultMergeDirs(child, filename, parent):
  768.     basename = os.path.splitext(os.path.basename(filename))[0]
  769.     for dir in reversed(xdg_config_dirs):
  770.         __parseMergeDir(os.path.join(dir, "menus", basename + "-merged"), child, filename, parent)
  771.  
  772. def __mergeFile(filename, child, parent):
  773.     # check for infinite loops
  774.     if filename in tmp["mergeFiles"]:
  775.         if debug:
  776.             raise ParsingError('Infinite MergeFile loop detected', filename)
  777.         else:
  778.             return
  779.  
  780.     tmp["mergeFiles"].append(filename)
  781.  
  782.     # load file
  783.     try:
  784.         doc = xml.dom.minidom.parse(filename)
  785.     except IOError:
  786.         if debug:
  787.             raise ParsingError('File not found', filename)
  788.         else:
  789.             return
  790.     except xml.parsers.expat.ExpatError:
  791.         if debug:
  792.             raise ParsingError('Not a valid .menu file', filename)
  793.         else:
  794.             return
  795.  
  796.     # append file
  797.     for child in doc.childNodes:
  798.         if child.nodeType == ELEMENT_NODE:
  799.             __parse(child,filename,parent)
  800.             break
  801.  
  802. # Legacy Dir Stuff
  803. def __parseLegacyDir(dir, prefix, filename, parent):
  804.     m = __mergeLegacyDir(dir,prefix,filename,parent)
  805.     if m:
  806.         parent += m
  807.  
  808. def __mergeLegacyDir(dir, prefix, filename, parent):
  809.     dir = __check(dir,filename,"dir")
  810.     if dir and dir not in tmp["DirectoryDirs"]:
  811.         tmp["DirectoryDirs"].append(dir)
  812.  
  813.         m = Menu()
  814.         m.AppDirs.append(dir)
  815.         m.DirectoryDirs.append(dir)
  816.         m.Name = os.path.basename(dir)
  817.         m.NotInXml = True
  818.  
  819.         for item in os.listdir(dir):
  820.             try:
  821.                 if item == ".directory":
  822.                     m.Directories.append(item)
  823.                 elif os.path.isdir(os.path.join(dir,item)):
  824.                     m.addSubmenu(__mergeLegacyDir(os.path.join(dir,item), prefix, filename, parent))
  825.             except UnicodeDecodeError:
  826.                 continue
  827.  
  828.         tmp["cache"].addMenuEntries([dir],prefix, True)
  829.         menuentries = tmp["cache"].getMenuEntries([dir], False)
  830.  
  831.         for menuentry in menuentries:
  832.             categories = menuentry.Categories
  833.             if len(categories) == 0:
  834.                 r = Rule("Include")
  835.                 r.parseFilename(menuentry.DesktopFileID)
  836.                 r.compile()
  837.                 m.Rules.append(r)
  838.             if not dir in parent.AppDirs:
  839.                 categories.append("Legacy")
  840.                 menuentry.Categories = categories
  841.  
  842.         return m
  843.  
  844. def __parseKDELegacyDirs(filename, parent):
  845.     f=os.popen3("kde-config --path apps")
  846.     output = f[1].readlines()
  847.     try:
  848.         for dir in output[0].split(":"):
  849.             __parseLegacyDir(dir,"kde", filename, parent)
  850.     except IndexError:
  851.         pass
  852.  
  853. # remove duplicate entries from a list
  854. def __removeDuplicates(list):
  855.     set = {}
  856.     list.reverse()
  857.     list = [set.setdefault(e,e) for e in list if e not in set]
  858.     list.reverse()
  859.     return list
  860.  
  861. # Finally generate the menu
  862. def __genmenuNotOnlyAllocated(menu):
  863.     for submenu in menu.Submenus:
  864.         __genmenuNotOnlyAllocated(submenu)
  865.  
  866.     if menu.OnlyUnallocated == False:
  867.         tmp["cache"].addMenuEntries(menu.AppDirs)
  868.         menuentries = []
  869.         for rule in menu.Rules:
  870.             menuentries = rule.do(tmp["cache"].getMenuEntries(menu.AppDirs), rule.Type, 1)
  871.         for menuentry in menuentries:
  872.             if menuentry.Add == True:
  873.                 menuentry.Parents.append(menu)
  874.                 menuentry.Add = False
  875.                 menuentry.Allocated = True
  876.                 menu.MenuEntries.append(menuentry)
  877.  
  878. def __genmenuOnlyAllocated(menu):
  879.     for submenu in menu.Submenus:
  880.         __genmenuOnlyAllocated(submenu)
  881.  
  882.     if menu.OnlyUnallocated == True:
  883.         tmp["cache"].addMenuEntries(menu.AppDirs)
  884.         menuentries = []
  885.         for rule in menu.Rules:
  886.             menuentries = rule.do(tmp["cache"].getMenuEntries(menu.AppDirs), rule.Type, 2)
  887.         for menuentry in menuentries:
  888.             if menuentry.Add == True:
  889.                 menuentry.Parents.append(menu)
  890.             #   menuentry.Add = False
  891.             #   menuentry.Allocated = True
  892.                 menu.MenuEntries.append(menuentry)
  893.  
  894. # And sorting ...
  895. def sort(menu):
  896.     menu.Entries = []
  897.     menu.Visible = 0
  898.  
  899.     for submenu in menu.Submenus:
  900.         sort(submenu)
  901.  
  902.     tmp_s = []
  903.     tmp_e = []
  904.  
  905.     for order in menu.Layout.order:
  906.         if order[0] == "Filename":
  907.             tmp_e.append(order[1])
  908.         elif order[0] == "Menuname":
  909.             tmp_s.append(order[1])
  910.     
  911.     for order in menu.Layout.order:
  912.         if order[0] == "Separator":
  913.             separator = Separator(menu)
  914.             if len(menu.Entries) > 0 and isinstance(menu.Entries[-1], Separator):
  915.                 separator.Show = False
  916.             menu.Entries.append(separator)
  917.         elif order[0] == "Filename":
  918.             menuentry = menu.getMenuEntry(order[1])
  919.             if menuentry:
  920.                 menu.Entries.append(menuentry)
  921.         elif order[0] == "Menuname":
  922.             submenu = menu.getMenu(order[1])
  923.             if submenu:
  924.                 __parse_inline(submenu, menu)
  925.         elif order[0] == "Merge":
  926.             if order[1] == "files" or order[1] == "all":
  927.                 menu.MenuEntries.sort()
  928.                 for menuentry in menu.MenuEntries:
  929.                     if menuentry not in tmp_e:
  930.                         menu.Entries.append(menuentry)
  931.             elif order[1] == "menus" or order[1] == "all":
  932.                 menu.Submenus.sort()
  933.                 for submenu in menu.Submenus:
  934.                     if submenu.Name not in tmp_s:
  935.                         __parse_inline(submenu, menu)
  936.  
  937.     # getHidden / NoDisplay / OnlyShowIn / NotOnlyShowIn / Deleted / NoExec
  938.     for entry in menu.Entries:
  939.         entry.Show = True
  940.         menu.Visible += 1
  941.         if isinstance(entry, Menu):
  942.             if entry.Deleted == True:
  943.                 entry.Show = "Deleted"
  944.                 menu.Visible -= 1
  945.             elif isinstance(entry.Directory, MenuEntry):
  946.                 if entry.Directory.DesktopEntry.getNoDisplay() == True:
  947.                     entry.Show = "NoDisplay"
  948.                     menu.Visible -= 1
  949.                 elif entry.Directory.DesktopEntry.getHidden() == True:
  950.                     entry.Show = "Hidden"
  951.                     menu.Visible -= 1
  952.         elif isinstance(entry, MenuEntry):
  953.             if entry.DesktopEntry.getNoDisplay() == True:
  954.                 entry.Show = "NoDisplay"
  955.                 menu.Visible -= 1
  956.             elif entry.DesktopEntry.getHidden() == True:
  957.                 entry.Show = "Hidden"
  958.                 menu.Visible -= 1
  959.             elif entry.DesktopEntry.getTryExec() and not __try_exec(entry.DesktopEntry.getTryExec()):
  960.                 entry.Show = "NoExec"
  961.                 menu.Visible -= 1
  962.             elif xdg.Config.windowmanager:
  963.                 if ( entry.DesktopEntry.getOnlyShowIn() != [] and xdg.Config.windowmanager not in entry.DesktopEntry.getOnlyShowIn() ) \
  964.                 or xdg.Config.windowmanager in entry.DesktopEntry.getNotShowIn():
  965.                     entry.Show = "NotShowIn"
  966.                     menu.Visible -= 1
  967.         elif isinstance(entry,Separator):
  968.             menu.Visible -= 1
  969.  
  970.     # remove separators at the beginning and at the end
  971.     if len(menu.Entries) > 0:
  972.         if isinstance(menu.Entries[0], Separator):
  973.             menu.Entries[0].Show = False
  974.     if len(menu.Entries) > 1:
  975.         if isinstance(menu.Entries[-1], Separator):
  976.             menu.Entries[-1].Show = False
  977.  
  978.     # show_empty tag
  979.     for entry in menu.Entries:
  980.         if isinstance(entry,Menu) and entry.Layout.show_empty == "false" and entry.Visible == 0:
  981.             entry.Show = "Empty"
  982.             menu.Visible -= 1
  983.             if entry.NotInXml == True:
  984.                 menu.Entries.remove(entry)
  985.  
  986. def __try_exec(executable):
  987.     paths = os.environ['PATH'].split(os.pathsep)
  988.     if not os.path.isfile(executable):
  989.         for p in paths:
  990.             f = os.path.join(p, executable)
  991.             if os.path.isfile(f):
  992.                 if os.access(f, os.X_OK):
  993.                     return True
  994.     else:
  995.         if os.access(executable, os.X_OK):
  996.             return True
  997.     return False
  998.  
  999. # inline tags
  1000. def __parse_inline(submenu, menu):
  1001.     if submenu.Layout.inline == "true":
  1002.         if len(submenu.Entries) == 1 and submenu.Layout.inline_alias == "true":
  1003.             menuentry = submenu.Entries[0]
  1004.             menuentry.DesktopEntry.set("Name", submenu.getName(), locale = True)
  1005.             menuentry.DesktopEntry.set("GenericName", submenu.getGenericName(), locale = True)
  1006.             menuentry.DesktopEntry.set("Comment", submenu.getComment(), locale = True)
  1007.             menu.Entries.append(menuentry)
  1008.         elif len(submenu.Entries) <= submenu.Layout.inline_limit or submenu.Layout.inline_limit == 0:
  1009.             if submenu.Layout.inline_header == "true":
  1010.                 header = Header(submenu.getName(), submenu.getGenericName(), submenu.getComment())
  1011.                 menu.Entries.append(header)
  1012.             for entry in submenu.Entries:
  1013.                 menu.Entries.append(entry)
  1014.         else:
  1015.             menu.Entries.append(submenu)
  1016.     else:
  1017.         menu.Entries.append(submenu)
  1018.  
  1019. class MenuEntryCache:
  1020.     "Class to cache Desktop Entries"
  1021.     def __init__(self):
  1022.         self.cacheEntries = {}
  1023.         self.cacheEntries['legacy'] = []
  1024.         self.cache = {}
  1025.  
  1026.     def addMenuEntries(self, dirs, prefix="", legacy=False):
  1027.         for dir in dirs:
  1028.             if not self.cacheEntries.has_key(dir):
  1029.                 self.cacheEntries[dir] = []
  1030.                 self.__addFiles(dir, "", prefix, legacy)
  1031.  
  1032.     def __addFiles(self, dir, subdir, prefix, legacy):
  1033.         for item in os.listdir(os.path.join(dir,subdir)):
  1034.             if os.path.splitext(item)[1] == ".desktop":
  1035.                 try:
  1036.                     menuentry = MenuEntry(os.path.join(subdir,item), dir, prefix)
  1037.                 except ParsingError:
  1038.                     continue
  1039.  
  1040.                 self.cacheEntries[dir].append(menuentry)
  1041.                 if legacy == True:
  1042.                     self.cacheEntries['legacy'].append(menuentry)
  1043.             elif os.path.isdir(os.path.join(dir,subdir,item)) and legacy == False:
  1044.                 self.__addFiles(dir, os.path.join(subdir,item), prefix, legacy)
  1045.  
  1046.     def getMenuEntries(self, dirs, legacy=True):
  1047.         list = []
  1048.         ids = []
  1049.         # handle legacy items
  1050.         appdirs = dirs[:]
  1051.         if legacy == True:
  1052.             appdirs.append("legacy")
  1053.         # cache the results again
  1054.         key = "".join(appdirs)
  1055.         try:
  1056.             return self.cache[key]
  1057.         except KeyError:
  1058.             pass
  1059.         for dir in appdirs:
  1060.             for menuentry in self.cacheEntries[dir]:
  1061.                 try:
  1062.                     if menuentry.DesktopFileID not in ids:
  1063.                         ids.append(menuentry.DesktopFileID)
  1064.                         list.append(menuentry)
  1065.                     elif menuentry.getType() == "System":
  1066.                     # FIXME: This is only 99% correct, but still...
  1067.                         i = list.index(menuentry)
  1068.                         e = list[i]
  1069.                         if e.getType() == "User":
  1070.                             e.Original = menuentry
  1071.                 except UnicodeDecodeError:
  1072.                     continue
  1073.         self.cache[key] = list
  1074.         return list
  1075.